package com.shujia.scala

object Demo15List {
  def main(args: Array[String]): Unit = {
    /**
     * scala集合
     * 1、List: 有序，不唯一
     * 2、Set ：无序，唯一
     * 3、Map: kv格式   key是唯一的
     * 4、Tuple: 元组，固定长度集合
     *
     */


    /**
     * List集合
     * scal的集合比java的集合好用-多了很多的方法
     *
     */
    //不可变的List
    val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2)

    //通过下标获取数据
    println(list(3))
    //获取第一个元素
    println(list.head)
    //获取最后一个元素
    println(list.last)
    //获取不包含第一个元素的所有的元素
    println(list.tail)
    //将集合中的元素拼接成一个字符串
    println(list.mkString("|"))
    //反转，返回一个新的List
    println(list.reverse)
    //取前n个元素
    println(list.take(4))
    //取后n个元素
    println(list.takeRight(4))
    //去重
    println(list.distinct)
    //求和，集合元素的类型必须是可以求和的类型
    println(list.sum)
    //取最大值
    println(list.max)
    //最小值
    println(list.min)

    println("=" * 100)

    /**
     * foreach: 循环集合，将集合中的元素一个一个传递给后面的函数，foreach没有返回值
     *
     */
    var sum = 0
    //循环统计总和
    list.foreach((i: Int) => {
      sum += i
    })
    println(sum)

    /**
     * 给每个元素加一（处理集合中的元素）
     *
     */

    println("=" * 100)
    for (i <- list) {
      val j = i * 2
      println(j)
    }

    /**
     * map:循环集合将集合中的元素一个一个传递给后面的函数，函数的返回值会构建出一个新的集合
     * i代表的是集合中所有的元素
     */

    val mapList: List[Int] = list.map((i: Int) => i + 1)

    println(mapList)


    /**
     * 处理集合中的元素，偶数加1，奇数乘以2
     *
     */
    val list2: List[Int] = list.map((i: Int) => {
      if (i % 2 == 1) {
        i * 2
      } else {
        i + 1
      }
    })
    println(list2)


    /**
     * 取出集合中奇数
     * Filter: 循环集合，将集合中的元素一个一个传递给后面的函数
     * 如果函数返回true保留数据，如果函数返回false过滤数据
     */
    val jishuList: List[Int] = list.filter((i: Int) => i % 2 == 1)
    println(jishuList)

    println("=" * 100)

    /**
     * 将一行中的多个单词拆分出来，一个单纯一行
     *
     */

    val linesList = List("java,spark,hadoop", "datax,scala,java", "hadoop,hive,sqoop")

    for (line <- linesList) {
      val split: Array[String] = line.split(",")
      for (word <- split) {
        println(word)
      }
    }
    println("=" * 100)
    /**
     * flatMap: 循环集合中的元素，将袁术一个一个传递给后面的函数
     * 函数返回一个集合，flatMap会将返回的集合拆分出来构建成一个新的集合
     *
     */
    val wordsList: List[String] = linesList.flatMap((line: String) => line.split(","))
    wordsList.foreach(println)

    println("=" * 100)
    /**
     * 多集合排序
     * sortBy: 需要指定一个排序的字段，默认是升序
     * sortWith: 指定一个排序的比较规则
     *
     */
    val list3: List[Int] = List(1, 2, 3, 4, 6, 4, 4, 2, 1, 1, 2, 3, 4, 2, 32, 4, 5, 6)

    val sortByList = list3.sortBy((i: Int) => -i)
    println(sortByList)


    val sortWithList = list3.sortWith((x: Int, y: Int) => x > y)
    println(sortWithList)

    println("=" * 100)
    /**
     *
     * groupBy: 分组，需要指定一个分组的字段
     *
     */
    val words = List("java", "spark", "java", "java", "spark", "hadoop")

    val groupByList: Map[String, List[String]] = words.groupBy((word: String) => word)

    groupByList.foreach(println)

    /**
     * 以下所有的方法都是返回新的集合，不会修改原始的集合
     * 同时以下这些方法在set集合中也有，除了sort
     * foreach:遍历数据
     * map：一条一条处理数据
     * filter：过滤数据
     * flatMap:将一行转换成多行
     * sortBy：排序
     * groupBy：分组
     *
     */

  }

}
